package com.cdzs.twocamera.util;

import java.nio.ByteOrder;

/**
 * Created by M_genius on 2018/7/10.\
 * 描述:
 * 数字工具类，用于将float int char 等基本数据类型转换为字节数组
 */

public class NumberUtil {

    // char转换为byte[2]数组
    public static byte[] getByteArray(char c) {
        byte[] b = new byte[2];
        b[0] = (byte) ((c & 0xff00) >> 8);
        b[1] = (byte) (c & 0x00ff);
        return b;
    }

    // 从byte数组的index处的连续两个字节获得一个char
    public static char getChar(byte[] arr, int index) {
        return (char) (0xff00 & arr[index] << 8 | (0xff & arr[index + 1]));
    }

    // short转换为byte[2]数组
    public static byte[] getByteArray(short s) {
        byte[] b = new byte[2];
        b[0] = (byte) ((s & 0xff00) >> 8);
        b[1] = (byte) (s & 0x00ff);
        return b;
    }

    // 从byte数组的index处的连续两个字节获得一个short
    public static short getShort(byte[] arr, int index) {
        return (short) (0xff00 & arr[index] << 8 | (0xff & arr[index + 1]));
    }

    // int转换为byte[4]数组
    public static byte[] getByteArray(int i) {
        byte[] b = new byte[4];
        b[0] = (byte) ((i & 0xff000000) >> 24);
        b[1] = (byte) ((i & 0x00ff0000) >> 16);
        b[2] = (byte) ((i & 0x0000ff00) >> 8);
        b[3] = (byte) (i & 0x000000ff);
//
//        b[3] = (byte) ((i & 0xff000000) >> 24);
//        b[2] = (byte) ((i & 0x00ff0000) >> 16);
//        b[1] = (byte) ((i & 0x0000ff00) >> 8);
//        b[0] = (byte) (i & 0x000000ff);
        return b;
    }

    // 从byte数组的index处的连续4个字节获得一个int
    public static int getInt(byte[] arr, int index) {
        return (0xff000000 & (arr[index + 0] << 24)) |
                (0x00ff0000 & (arr[index + 1] << 16)) |
                (0x0000ff00 & (arr[index + 2] << 8)) |
                (0x000000ff & arr[index + 3]);
    }

    // float转换为byte[4]数组
    public static byte[] getByteArray(float f) {
        int intbits = Float.floatToIntBits(f);//将float里面的二进制串解释为int整数
        return getByteArray(intbits);
    }

    // 从byte数组的index处的连续4个字节获得一个float
    public static float getFloat(byte[] arr, int index) {
        return Float.intBitsToFloat(getInt(arr, index));
    }

    // long转换为byte[8]数组
    public static byte[] getByteArray(long l) {
        byte b[] = new byte[8];
        b[0] = (byte) (0xff & (l >> 56));
        b[1] = (byte) (0xff & (l >> 48));
        b[2] = (byte) (0xff & (l >> 40));
        b[3] = (byte) (0xff & (l >> 32));
        b[4] = (byte) (0xff & (l >> 24));
        b[5] = (byte) (0xff & (l >> 16));
        b[6] = (byte) (0xff & (l >> 8));
        b[7] = (byte) (0xff & l);
        return b;
    }

    // 从byte数组的index处的连续8个字节获得一个long
    public static long getLong(byte[] arr, int index) {
        return (0xff00000000000000L & ((long) arr[index + 0] << 56)) |
                (0x00ff000000000000L & ((long) arr[index + 1] << 48)) |
                (0x0000ff0000000000L & ((long) arr[index + 2] << 40)) |
                (0x000000ff00000000L & ((long) arr[index + 3] << 32)) |
                (0x00000000ff000000L & ((long) arr[index + 4] << 24)) |
                (0x0000000000ff0000L & ((long) arr[index + 5] << 16)) |
                (0x000000000000ff00L & ((long) arr[index + 6] << 8)) |
                (0x00000000000000ffL & (long) arr[index + 7]);
    }

    // double转换为byte[8]数组
    public static byte[] getByteArray(double d) {
        long longbits = Double.doubleToLongBits(d);
        return getByteArray(longbits);
    }

    // 从byte数组的index处的连续8个字节获得一个double
    public static double getDouble(byte[] arr, int index) {
        return Double.longBitsToDouble(getLong(arr, index));
    }

    public static void main(String[] args) {
        System.out.println(ByteOrder.nativeOrder());
        if (args.length < 1) {
            System.out.println("enter 'char' test method about char");
            System.out.println("enter 'short' test method about short");
            System.out.println("enter 'int' test method about int");
            System.out.println("enter 'float' test method about float");
            System.out.println("enter 'long' test method about long");
            System.out.println("enter 'double' test method about double");
            return;
        }
        if (args[0].equals("char")) {
            char c = '\u0000';
            while (c < '\uffff') {
                System.out.println(getChar(getByteArray(c), 0));
                c++;
            }
        } else if (args[0].equals("short")) {
            short s = Short.MIN_VALUE;
            while (s < Short.MAX_VALUE) {
                System.out.println(getShort(getByteArray(s), 0));
                s++;
            }
        } else if (args[0].equals("int")) {
            int i = Integer.MIN_VALUE;
            while (i < Integer.MAX_VALUE) {
                System.out.println(getInt(getByteArray(i), 0));
                i++;
            }
        } else if (args[0].equals("float")) {
            float f = Float.MIN_VALUE;
            while (f < Float.MAX_VALUE) {
                System.out.println(getFloat(getByteArray(f), 0));
                f += 1.1111f;
            }
        } else if (args[0].equals("long")) {
            long l = Long.MIN_VALUE;
            while (l < Long.MAX_VALUE) {
                System.out.println(getLong(getByteArray(l), 0));
                l++;
            }
        } else if (args[0].equals("double")) {
            double d = Double.MIN_VALUE;
            while (d < Double.MAX_VALUE) {
                System.out.println(getDouble(getByteArray(d), 0));
                d += 1.111D;
            }
        }
    }


}
